% Código fuente del tp
\section{Apéndice A}

Dada la extensión del código se seleccionaron las partes más importantes a saber:

\textbf{Definición de la clase Float}

{\scriptsize
\begin{verbatim}
#ifndef __FLOAT__
#define __FLOAT__

#include <sstream>
#include <iostream>
#include <string>
#include <cassert>
#include <bitset>
#define MAX_PRECISION 50
#define COTA_POR_PERIODICO MAX_PRECISION
#define nat unsigned short
#define unsh(a) (((nat)a)&0xff)
typedef char byte;

using namespace std;

class Float{
	
	public:

		/**
		 * Constructores
		 */
		Float();
		Float(const string&);
		Float(const float&);
		Float(const Float&);
		~Float();
		Float& operator=(const Float&);

		/**cout
		 * operadores de comparacion
		 */
		bool operator== (const Float&) const;
		bool operator!=(const Float&) const;
		bool operator<(const Float&) const;
		bool operator<=(const Float&) const;
		bool operator>(const Float&) const;
		bool operator>=(const Float&) const;
		
		/**
		 * operadores aritmeticos
		 */
		Float operator+(const Float&) const;
		Float operator-(const Float&) const;
		Float operator*(const Float&) const;
		Float operator>>(const unsigned int&);


		/**
		 * operadores de asignacion y aritmeticos
		 */
		void operator+=(const Float&);
		void operator-=(const Float&);
		void operator*=(const Float&);
		void operator>>=(unsigned int);
		
		string mostrar() const;
	
		char* dameMantisa() const;
		int damePre() const;
		int dameExp() const;
		bool dameSig() const;

	private:
		void signoYSeparar(const string&,string&,string&);
		void dividirPorDos(byte*, int, int);
		bool multPorDos(byte*, int);
		void reverse(string&);
		void entChar2bin(string&);
		void fracChar2bin(string&);
		void calcularPotencia(string&, string&);
		
		// mantisa[0] es la parte mas significativa (big-indian)
		char* mantisa;
		int precision;
		int exponente;
		bool signo;

};
\end{verbatim} }

\textbf{Suma de Floats}

{\scriptsize
\begin{verbatim}
void Float::operator+=(const Float& f){
    if(f == Float("0.0")){
        return;
    }
	if(*this == Float("0.0")){
        *this = f;
        return;
    }
    if(*this == f){
    	Float dos("2");
    	(*this) *= dos;
    	return;
    }
    this->signo = !this->signo;
    if( *this == f ){
        *this = Float("0.0");
        return;
    }
    this->signo = !this->signo;
    
    
    
	if(this->signo == f.signo){
		int inicio;
		bool carry;
		byte * result;
		// separo aguas
		// hago la cuenta principal en funcion del exponente
		if(this->exponente < f.exponente){
            // salvo la precision de este.
			int thisPreci = this->precision;
			// calulo la precision.
			if(this->precision + (f.exponente - this->exponente) < f.precision){
				this->precision = f.precision;
			} else { 
				this->precision += (f.exponente - this->exponente);
			}
            if(this->precision >= MAX_PRECISION)
                this->precision = MAX_PRECISION - 1;
			// relleno el arreglo final
			result = new byte[this->precision];
			assert(this->precision >= f.precision);
			for(int x = 0; x < f.precision; x++)
				result[x] = f.mantisa[x];
				
			for(int x = f.precision; x < this->precision; x++)	
				result[x] = 0;
				
			// averiguo donde empieza el numero mas chico en el arreglo final.
			int inicio = f.exponente - this->exponente;
            if(inicio >= MAX_PRECISION)
                inicio = MAX_PRECISION - 1;
			assert(inicio <= this->precision);
			carry = false;
			//obtener el it del mas chico (es necesario el if, por los %MAXPRECI)
			int itChico;
			if(this->precision - inicio > thisPreci){
				itChico = thisPreci-1;
			} else {
				itChico = this->precision - inicio - 1;
			}
			//hago las cuentas
			for(int x = itChico; x>=0; x--){
				byte pre = result[inicio + x];
				result[inicio + x] += ((byte)(carry)?1:0);
				carry = unsh(pre) > unsh(result[inicio+x]);
				pre = result[inicio+x];
				result[inicio + x] += this->mantisa[x];
				carry = carry || unsh(pre) > unsh(result[inicio+x]);
                
			}
			// termino de pasar carries.
			int x = inicio - 1;
			while(carry && x >= 0){
				byte pre = result[x];
				result[x] += ((byte)(carry)?1:0);
				carry = unsh(pre) > unsh(result[x]);
                x--;
			}
			//actualizo exponente
			this->exponente = f.exponente;
		} else { //this->exponente >= f.exponente
			// salvo la precision de este.
			int thisPreci = this->precision;
			// calulo la precision.
			if(f.precision + this->exponente - f.exponente > this->precision){
				this->precision = f.precision;
				this->precision += (this->exponente - f.exponente);
			}

           
           if(this->precision >= MAX_PRECISION)
               this->precision = MAX_PRECISION - 1;
			// relleno el arreglo final
			result 	= new byte[this->precision];
			assert(this->precision >= thisPreci);
			for(int x = 0; x < thisPreci; x++)
				result[x] = this->mantisa[x];
				
			for(int x = thisPreci; x < this->precision; x++)	
				result[x] = 0;
				
			// averiguo donde empieza el numero mas chico en el arreglo final.
			int inicio = this->exponente - f.exponente;
            if(inicio >= MAX_PRECISION)
                inicio = MAX_PRECISION - 1;
			carry = false;
			//obtener el it del mas chico (es necesario el if, por los %MAXPRECI)
			int itChico;
			if(this->precision - inicio > f.precision){
				itChico = f.precision-1;
			} else {
				itChico = this->precision - inicio - 1;
			}
			//hago las cuentas
			for(int x = itChico; x>=0; x--){
				byte pre = result[inicio + x];
				result[inicio + x] += ((byte)(carry)?1:0);
				carry = unsh(pre) > unsh(result[inicio+x]);
				pre = result[inicio+x];
				result[inicio + x] += f.mantisa[x];
				carry = carry || unsh(pre) > unsh(result[inicio+x]);
			}
			//termino de pasar carries
			int x = inicio - 1;
			while(carry && x >= 0){
				byte pre = result[x];
				result[x] += ((byte)(carry)?1:0);
				carry = unsh(pre) > unsh(result[x]);
                x--;
			}
		}
		// a partir de aqui independiente de los floats paramatros
		//en caso de q se haya carry al finalizar
        
        if(this->mantisa != NULL){
            delete[]this->mantisa;
            this->mantisa = NULL;
        }
		if(carry && (this->precision-1) < MAX_PRECISION){
			this->mantisa = new byte[this->precision+1];
			this->mantisa[0] = 1;
            for(int x = 0; +x < this->precision; x++)
				this->mantisa[x+1] = result[x];
			this->precision++;
            this->exponente++;
		} else if(carry && !(this->precision < MAX_PRECISION)) {
			this->mantisa = new byte[this->precision];
            this->mantisa[0] = 1;
			for(int x = 1; x < this->precision;x++)
				this->mantisa[x] = result[x-1];
            this->exponente++;
		} else {
			this->mantisa = result;
			result = NULL;
		}
		if(result!= NULL){
			delete[]result;
            result = NULL;
        }
		//por como se hace la suma no deberia haber ceros al principio.
		assert(this->mantisa[0]!=0);
		// normalizo (quitar ceros del final);
		int pos = this->precision-1;
		int ceros = 0;
		while(pos >= 0 && mantisa[pos] == 0){
			ceros++;
            pos--;
		}
		if(ceros > 0){
			byte * temp;
			this->precision -= ceros;
			temp = this->mantisa;
			this->mantisa = new byte[this->precision];
			for(int x = 0; x < this->precision ; x++ )
				this->mantisa[x] = temp[x];
            delete[]temp;
		}
	} else {// distinto signo.
        bool borrow;
        byte* result;
		Float aux(f);
		bool elSigno = this->signo;
		this->signo = false;
		aux.signo = false;
		//me guardo el signo de this y les calculo el modulo (sacarle el signo)
		//una vez hecho eso comparo y separo entre el mas grande y el mas chico.
		if(*this > aux){
            // |this| > |f|
            // this en modulo es mayor a f en modulo.
            // salvo la precision de este.
            int thisPreci = this->precision;
            // calulo la precision.
            if(f.precision + this->exponente - f.exponente >= this->precision){
                this->precision = f.precision;
                this->precision += (this->exponente - f.exponente);
            }
            
            if(this->precision >= MAX_PRECISION)
                this->precision = MAX_PRECISION - 1;
            
            // relleno el arreglo final
            result  = new byte[this->precision];
            for(int x = 0; x < thisPreci; x++)
                result[x] = this->mantisa[x];
            
            for(int x = thisPreci; x < this->precision; x++)    
                result[x] = 0;
            
            // averiguo donde empieza el numero mas chico en el arreglo final.
            int inicio = this->exponente - f.exponente;
            if(inicio >= MAX_PRECISION)
                inicio = MAX_PRECISION - 1;
            assert(inicio <= this->precision);
            borrow = false;
            //obtener el it del mas chico (es necesario el if, por los %MAXPRECI)
            int itChico;
            if(this->precision - inicio > f.precision){
                itChico = f.precision-1;
            } else {
                itChico = this->precision - inicio - 1;
            }
            //hago las cuentas
            for(int x = itChico; x>=0; x--){
                byte pre = result[inicio + x];
                result[inicio + x] -= ((byte)(borrow)?1:0);
                borrow = unsh(pre) < unsh(result[inicio+x]);
                pre = result[inicio+x];
                result[inicio + x] -= f.mantisa[x];
                borrow = borrow || unsh(pre) < unsh(result[inicio+x]);
            }
            //termino de sacar borrows
            int x = inicio - 1;
            while(borrow && x >= 0){
                byte pre = result[x];
                result[x] -= ((byte)(borrow)?1:0);
                borrow = unsh(pre) < unsh(result[x]);
                x--;
            }
            this->signo = elSigno;
		} else {
            // |this| <= |f|
            // this en modulo es menor a f en modulo.
            // salvo la precision de este.
            int thisPreci = this->precision;
            // calulo la precision.
            if(this->precision + f.exponente - this->exponente > f.precision){
                this->precision += (f.exponente - this->exponente);
            } else {
                this->precision = f.precision;
            }
            
            if(this->precision >= MAX_PRECISION)
                this->precision = MAX_PRECISION - 1;
            // relleno el arreglo final
            result  = new byte[this->precision];
            for(int x = 0; x < f.precision; x++)
                result[x] = f.mantisa[x];
            
            for(int x = f.precision; x < this->precision; x++)    
                result[x] = 0;
            
            // averiguo donde empieza el numero mas chico en el arreglo final.
            int inicio = f.exponente - this->exponente;
            if(inicio >= MAX_PRECISION)
                inicio = MAX_PRECISION - 1;
            assert(inicio <= this->precision);
            borrow = false;
            //obtener el it del mas chico (es necesario el if, por los %MAXPRECI)
            int itChico;
            if(this->precision - inicio > thisPreci){
                itChico = thisPreci-1;
            } else {
                itChico = this->precision - inicio - 1;
            }
            //hago las cuentas
            for(int x = itChico; x>=0; x--){
                byte pre = result[inicio + x];
                result[inicio + x] -= ((byte)(borrow)?1:0);
                borrow = unsh(pre) < unsh(result[inicio+x]);
                pre = result[inicio+x];
                result[inicio + x] -= this->mantisa[x];
                borrow = borrow || unsh(pre) < unsh(result[inicio+x]);
            }
            //termino de sacar borrows
            int x = inicio - 1;
            while(borrow && x >= 0){
                byte pre = result[x];
                result[x] -= ((byte)(borrow)?1:0);
                borrow = unsh(pre) < unsh(result[x]);
                x--;
            }
            this->signo = !elSigno;
            this->exponente = f.exponente;
		}
        assert(!borrow);
        if(this->mantisa != NULL){
            delete [] this->mantisa;
            this->mantisa = NULL;
        }
        this->mantisa = new byte[this->precision];
        for(int x = 0; x < this->precision; x++)
            this->mantisa[x] = result[x];
        //normalizacion
        int correrPrecision = 0;
        for( int x = this->precision-1; x>=0 && this->mantisa[x] == 0; x--){
            correrPrecision++;
        }
        this->precision -= correrPrecision;
        if(precision!=0){
            int restarExponente = 0;
            for(int x = 0; this->mantisa[x] == 0; x++){
                restarExponente++;
            }
            this->precision -= restarExponente;
            this->exponente -= restarExponente;
            byte* temp = this->mantisa;
            this->mantisa = new byte[this->precision];
            for(int pos = 0; pos < this->precision; pos++){
                this->mantisa[pos] = temp[restarExponente + pos];
            }
            delete []temp;
        }
        if(this->precision == 0){
            this->signo = false;
            this->exponente = 0;
            if(this->mantisa != NULL){
                delete [] this->mantisa;
                this->mantisa = NULL;
            }
        }
		
	}
\end{verbatim} }

\textbf{Multiplicación de Floats}

{\scriptsize
\begin{verbatim}
void Float::operator*=(const Float& f){
    if( *this == Float("0.0") || f == Float("0.0")){
        this->precision = 0;
        this->exponente = 0;
        this->signo = false;
        if(this->mantisa != NULL){
            delete[] this->mantisa;
            this->mantisa = NULL;
        }
        this->mantisa = NULL;
        return;
    }
	this->signo = (this->signo != f.signo);
	this->exponente += f.exponente;
	byte* num1;
	nat* result;
	const byte* num2;
	int size;
	if(this->precision < f.precision) {
		size = f.precision;
		num2 = f.mantisa;
		num1 = new byte[size];
		for(int i=0; i < this->precision; i++)
			num1[i] = this->mantisa[i];
		for(int i = this->precision; i < size; i++)
			num1[i] = 0;
	} else {
		size = this->precision;
		num2 = this->mantisa;
		num1 = new byte[size];
		for(int i = 0; i < f.precision; i++)
			num1[i] = f.mantisa[i];
		for(int i = f.precision; i < size; i++)
			num1[i] = 0;
	}
	this->precision = 2*size;
	result = new nat[this->precision];
	for(int x = 0; x < this->precision; x++)
		result[x] =0;
	nat carry;
	for(int x = 0; x <size; x++){
		carry = 0;
		nat value1 = unsh(num1[size - 1 - x]);
		int pos = x;
		for(int y = 0; y < size; y++){
			nat value2 = unsh(num2[size - 1 - y]);
			result[pos] += carry;
			carry = (result[pos]>>8)&0xff;
			result[pos] &= 0xff;
			result[pos] += value2*value1;
            carry += (result[pos]>>8)&0xff;
			result[pos] &= 0xff;
			pos++;
		}
		while(carry!=0){
			result[pos]+=carry;
            carry = (result[pos]>>8)&0xff;
			result[pos] &= 0xff;
			pos++;			
		}
        assert(pos<=(size*2));
	}
	delete[] num1;
    if(this->mantisa != NULL){
        delete[] this->mantisa;
        this->mantisa = NULL;
    }
	this->mantisa = new byte[this->precision];
	for(int x = 0; x < this->precision; x++){
		if(result[x]>255){
			assert(false);
		}
		this->mantisa[this->precision -1 - x] = result[x];
	}
	delete[] result;
	int correrPrecision = 0;
	for( int x = this->precision-1; x>=0 && this->mantisa[x] == 0; x--){
		correrPrecision++;
	}
	this->precision -= correrPrecision;
	if(precision!=0){
		int restarExponente = 0;
		for(int x = 0; this->mantisa[x] == 0; x++){
			restarExponente++;
		}
		this->precision -= restarExponente;
		this->exponente -= restarExponente;
		byte* temp = this->mantisa;
		this->mantisa = new byte[this->precision];
		for(int pos = 0; pos < this->precision; pos++){
			this->mantisa[pos] = temp[restarExponente + pos];
		}
		delete []temp;
	} 
	if(this->precision == 0){
		this->signo = false;
		this->exponente = 0;
		if(this->mantisa != NULL){
			delete [] this->mantisa;
			this->mantisa = NULL;
		}
	}
}
\end{verbatim} }


\textbf{Definición de la clase Complex}

{\scriptsize
\begin{verbatim}
 #include <cassert>
#include <iostream>
#include <cstdlib>
#include "./../Float/Float.h"

using namespace std;
typedef Float inFloat;

class Complex{

 private: 			
	inFloat real;
	inFloat imaginario;

 public:
 
 	/**
 	 * Constructores
 	 */
	Complex();
	Complex(const inFloat&, const inFloat&);
	Complex(const float, const float);
	Complex(const Complex&);
	
	/**
	 *operadores
	 */
	Complex& suma(const Complex&); 
	Complex& producto(const Complex&);
	Complex& producto(const inFloat&); // producto x un lambda - REQUIERE el friend operator* en inFloat.h 
	inFloat moduloModulo() const; //Sería el módulo | |  al cuadrado (para evitar hacer raíz sobre el infloat)
	Complex& cuadrado(); 
	friend Complex operator+(const Complex&, const Complex&); // REQUEIRE: friend operator+ definido en inFloat
	friend Complex operator-(const Complex&, const Complex&); // REQUEIRE: friend operator- definido en inFloat
	friend Complex operator*(const Complex&, const Complex&); // REQUIERE: friend operator* definido en inFloat
	friend Complex operator*(const inFloat&, const Complex&); // Escalar! requiere lo de arriba	
	
	/**
	 * getters
	 */
	inFloat Re() const; // proyector de la componente real
	inFloat Im() const; // id. de la componenete imaginaria

	/**
	 * setters
	 */
	Complex& setRe(inFloat);
	Complex& setIm(inFloat);	

	/**
	 * comparaciones y asignacion
	 */
	bool operator==(const Complex&) const; 
	bool operator!=(const Complex&) const;	
	Complex& operator=(const Complex&);
};
\end{verbatim} }


\textbf{Suma y Multiplicación de números complejos}

{\scriptsize
\begin{verbatim}
 Complex& Complex::suma(const Complex& z){
	this->real += z.Re();
	this->imaginario += z.Im();
	return *this;
}

Complex& Complex::producto(const Complex& z){

	// por comodidad a this->imaginario lo llamo wi y a this->real lo llamo wr
	inFloat wr = this->real;
	this->real *= z.Re();
	this->real = this->real - (this->imaginario * z.Im());
	this->imaginario *= z.Re();
	wr*= z.Im();
	this->imaginario += wr;
	
	
	return *this;
}
\end{verbatim} }

\textbf{``Módulo cuadrado'' y cálculo del cuadrado de un complejo}

{\scriptsize
\begin{verbatim}
Complex& Complex::cuadrado(){
	inFloat wr = this->real; 
	
	this->real += this->imaginario;
	this->real *= (wr - this->imaginario);
	Float dos("2.0");
	this->imaginario *= dos;
	this->imaginario *= wr;
	
	
	return *this;
}
inFloat Complex::moduloModulo() const{
	inFloat ret(this->real);
	inFloat im(this->imaginario);
	ret*=ret;
	im *= im;
	ret+=im;
	return ret;
}

\end{verbatim} }


\textbf{Definición de la clase Mandelbrot}

{\scriptsize
\begin{verbatim}
 #ifndef __MANDELBROT_H__
#define __MANDELBROT_H__

#include <Python.h>
#include <iostream>
#include <numpy/arrayobject.h>
#include <cassert>
#include <iostream>
#include <cstdlib>
#include <string>
#include "./../Py/Video.h"
#include "./../Complejos/Complejo.h"

using namespace std;

#define MAX_ITERS 10 
#define WIDTH 6
#define HEIGHT WIDTH

class Mandelbrot{

 private:
	
	int* superficie;
	Float deltaX;
	Float deltaY;
	Complex posAnterior[2];
	Complex posActual[2];
	//funciones uso interno...
	int calcularPunto(Complex&);

	
	int p1,p2,p3,p4,p0;

 public:
	Mandelbrot();	
	Mandelbrot(int*);
	
	void genera(int, int);
	void genera(Complex);
	void genera(Complex&,Complex&);
	int colorear(int i);	

};

\end{verbatim} }


\textbf{Función de Color}

{\scriptsize
\begin{verbatim}
int Mandelbrot::colorear(int it){
	int valor = 0xFF000000;
	int i = 0;
	int cant = 0;

	int v = 0;

	unsigned char vr = 0;
	unsigned char vg = 0;
	unsigned char vb = 0;

	float er = 0.0;
	float eg = 0.0;
	float eb = 0.0;
	
	if(it < p0){
		i = it;
		
		er = (0x00 - 0x00) / p0;
		vr = 0x00 +i*er;
		eg = (0x00 - 0x00) / p0;
		vg = 0x00 + i*eg;
		eb = (0xff - 0x45) / p0;
		vb = 0xff - i*eb;
		valor +=  vr<<16;
		valor += vg<<8;
		valor += vb;


	} else if ( it < p1){
		cant = p1 - p0;
		i = it - p0;
		er = (0x02 - 0x00) / cant;
		vr = (0x00 + i*er);
		eg = (0x99 - 0x00) / cant;
		vg = (0x00 + i*eg);
		eb = (0x55 - 0x33) / cant;
		vb = 0x55 - i*eb;
		valor +=  vr<<16;
		valor += vg<<8;
		valor += vb;
	
	} else if (it < p2){
		cant = p2 - p1;
		i = it - p1;
		er = (0xff - 0x02) / cant;
		vr = (0x02 + i*er);
		eg = (0xdd - 0x99) / cant;
		vg = (0x99 + i*eg);
		eb = (0x33 - 0x00) / cant;
		vb = 0x33 - i*eb;
		valor += vr<<16;
		valor += vg<<8;
		valor += vb;


	} else if (it < p3){
		cant = p3 - p2;
		i = it - p2;

		er = (0xff - 0xff) / cant;
		vr = (0xff + i*er);
		eg = (0xdd - 0x22) / cant;
		vg = (0xdd - i*eg);
		eb = (0x22 - 0x00) / cant;
		vb = 0x00 + i*eb;
		valor += vr<<16;
		valor += vg<<8;
		valor += vb;
	

	} else if (it < p4){
		cant = p4 - p3;
		i = it - p3;
		
		er = (0xff - 0x88) / cant;
		vr = (0xff - i*er);
		eg = (0x22 - 0x00) / cant;
		vg = (0x22 - i*eg);
		eb = (0x88 - 0x22) / cant;
		vb = 0x00 + i*eb;
		valor += vr<<16;
		valor += vg<<8;
		valor += vb;

	} else if (it < MAX_ITERS){

		cant = MAX_ITERS - p4;
		i = it - p4;

		
		er = (0x88 - 0x00) / cant;
		vr = (0x88 - i*er);
		eg = (0x00 - 0x00) / cant;
		vg = (0x00 - i*eg);
		eb = (0x88 - 0x00) / cant;
		vb = 0x88 - i*eb;
		valor += vr<<16;
		valor += vg<<8;
		valor += vb;
	} else 
		valor = 0xff000000;
	return valor;


}
\end{verbatim} }

\textbf{Cálculo de Puntos y génesis del Mandelbrot}

{\scriptsize
\begin{verbatim}
 int Mandelbrot::calcularPunto(Complex& x){
	inFloat aux0("0,0");
	Complex a(aux0,aux0);
	unsigned int it = 0;
	inFloat cota("4.0");
	bool seEscapo;


    	seEscapo = a.moduloModulo() > cota;

	while(it < MAX_ITERS && !seEscapo) {
		a.cuadrado();
   		a.suma(x);
   		it++;
   		seEscapo = a.moduloModulo() > cota;

    	}

	return it;
		
}

void Mandelbrot::genera(Complex& z, Complex& w){ 
	//me guardo la posactual para la próxima
	Float Ancho = w.Re() - z.Re();
	posAnterior[0] = z;
	posAnterior[1] = w;
	
	deltaX = ( w.Re() - z.Re() )>>(WIDTH);
	deltaY = ( w.Im() - z.Im() )>>(HEIGHT);
	cout <<"z: "<< z << endl;
	cout <<"w: "<< w << endl;
	cout <<"deltaX = "<< deltaX << "/ deltaY = " << deltaY << endl;
	cout << "ancho = "<<Ancho << endl;
	int r=0;
	int c=0;
	while( z.Im() < (w.Im())  ) {
		while( z.Re() < w.Re() ) {
			cout << "C: " << c << endl;
			int i = calcularPunto(z);
			int valor =  colorear(i);
			superficie[c+r] = valor;
			c++;
			z.setRe( z.Re() + deltaX );
		}
		cout << "R: " << r << endl;
		r+= (1<<WIDTH);
		c=0;
		z.setRe(z.Re() - Ancho);
		z.setIm( z.Im() + deltaY);
	}
}
\end{verbatim}} 


\newpage

\section{Apéndice B}

\subsection*{Instrucciones para compilar/Instalar}

Para compilar:
paquetes necesarios:
\begin{verbatim}
ver = version de python
python (preferentemente version 2.6)
python{$ver}-dev
python-numpy
python-pygame
sdl
\end{verbatim}


En los laboratorios de la facultad estan instalados todos menos el paquete pygame, el cual se puede bajar de esta direccion:
\emph{www.pygame.org/download.shtml}

Para instalar pygame hacer lo siguiente:

Descomprimirlo

Entrar con la consola y correr en esa carpeta la siguiente instruccion:

python setup.py install --user

Luego para compilarlo utilizar el makefile con el target mandelbrot

Para correrlo por temas de compatibilidad con python es necesario correr el programa desde la carpeta donde se encuentra genVideo.py, eso es en:

/Py/ respecto de la carpeta principal del tp.

El comando seria el siguiente:
../Mandelbrot/mandelbrot

Recomendamos usar make float; Float/Float es una unidad que permite testear los numeros flotantes.

